Prévision des variations du bitcoin en fonction d'indicateurs techniques à partir de régression linéaire

• Analyse descriptive univariée des variations de la cotation du BTC : Comprendre la distribution des rendements, évaluer la volatilité sur différentes périodes (hebdomadaire, mensuelle, annuelle, intra-journalière), etc.
• Analyse descriptive multivariée des variations du BTC : Explorer l'influence des indicateurs techniques financiers sélectionnés sur les variations de la cotation du BTC.
• Développement d'un ou plusieurs modèles explicatifs pour les variations du BTC : Créer des modèles qui peuvent expliquer les variations du BTC en fonction des indicateurs techniques, par exemple à partir de régressions linéaires.
• Évaluation des performances prédictives des modèles mis en œuvre : Évaluer la capacité des modèles développés à prédire les variations du BTC.

Le travail est à réaliser avec le langage Python. Une montée en compétences est donc attendue en programmation Python, particulièrement sur la bibliothèque Pandas. En outre, il sera important de se familiariser avec le domaine de l'analyse financière pour comprendre comment les indicateurs techniques sont utilisés pour analyser et prédire les variations du marché.

Concernant Python la série de vidéos Formation Python Machine Learning est une ressource intéressante parmi d'autres pour se mettre à niveau avec ce langage.

Nous avons introduit précédemment la période d'échantillonnage des données \(\Delta t\). On note également \(t_{0}\) la première date d'échantillonnage. Dans l'exemple de données précédent, on rappelle que \(\Delta t = 5\) minutes et que \(t_{0} =\) 2021-01-01 00:00:00.

Nous introduisons ensuite l'indice \(p \ge 0\) permettant de référencer la \(p\) -ème période d'observation des données (cf. Figure 3), i.e. entre \(t_{0} + p\Delta t\) et \(t_{0} + (p+1)\Delta t\). En reprenant l'exemple précédent, on a :

• 1er période d'observation \(p = 0\) : période entre 2021-01-01 00:00:00 et 2021-01-01 00:05:00 ;
• 5ème période d'observation \(p = 4\) : période entre 2021-01-01 00:20:00 et 2021-01-01 00:25:00.

Les données OHLCV sont notées dans la suite comme suit :

• \(\text{o}_{p}\) : cotation de l'actif à l'ouverture de la période \(p\), i.e. à \(t = t_{0} + p\Delta t\) ;
• \(\text{c}_{p}\) : cotation de l'actif à la fermeture de la période \(p\), i.e. à \(t = t_{0} + (p+1)\Delta t\) ;
• \(\text{h}_{p}\) : cotation maximum de l'actif sur la période \(p\) ;
• \(\text{l}_{p}\) : cotation mimimum de l'actif sur la période \(p\) ;
• \(\text{v}_{p}\) : volume échangé de l'actif la période \(p\).

On note enfin \(r_{p}\) la variation relative de la cotation d'un actif entre deux périodes consécutives, on parle également de rendement (ou returns en anglais) sur la période \(p\). Nous avons donc pour tout \(p \ge 1\) :

La quantité \(r_{p}\) est donc positive si le BTC gagne en valeur par rapport à l'USDT sur la période \(p\) et négative sinon. Le rendement représente l'indicateur principal au coeur de toutes les analyses financières réalisées sur un actif donné.

La définition \eqref{org0db3dc9} porte sur un rendement entre deux périodes successives. Cette définition peut être étendue entre deux périodes \(p\) et \(p + k\) données (cf. Figure 4) comme suit :

avec \(k \ge 0\) un nombre entier permettant de définir le nombre de périodes futures à prendre en compte pour le calcul du rendement.

Exemples

Nous illustrons les définitions précédentes sur l'extrait de cotation BTC/USDT suivant.

import plotly.graph_objects as go

ohlcv_ex_df = ohlcv_df.head(10)
fig = go.Figure()
fig.add_trace(go.Candlestick(x=ohlcv_ex_df.index,
                             open=ohlcv_ex_df["open"],
                             high=ohlcv_ex_df["high"],
                             low=ohlcv_ex_df["low"],
                             close=ohlcv_ex_df["close"], name="OHLC"))
fig.update_layout(title="Exemple de données OHLC sur l'actif BTC/USDT",
                  yaxis_title="USDT",
                  xaxis_title="Temps",
                  xaxis_rangeslider_visible=False)

fig

Le calcul général du rendement de clôture à \(p + k\) avec Pandas repose sur la méthode .shift :

rho_pk = ohlcv_df["close"].shift(-k)/ohlcv_df["close"].shift(1) - 1

Un calcul alternatif équivalent utilise la méthode .pct_change :

rho_pk = ohlcv_df["close"].pct_change(k+1).shift(-k)

Même si à notre niveau les deux méthodes précédentes sont identiques, on privilégiera dans la suite l'utilisation de la méthode .pct_change car cette dernière possède une meilleure précision numérique.

Calculons les rendements à \(p\) et \(p + 2\) :

#rho_p = (ohlcv_ex_df["close"].shift(0)/ohlcv_ex_df["close"].shift(1) - 1).rename("returns")
#rho_p2 = (ohlcv_ex_df["close"].shift(-2)/ohlcv_ex_df["close"].shift(1) - 1).rename("returns_2")

rho_p = ohlcv_ex_df["close"].pct_change(1).shift(0).rename("returns")
# => équivalent à écrire rho_p = ohlcv_ex_df["close"].pct_change().rename("returns")

rho_p2 = ohlcv_ex_df["close"].pct_change(3).shift(-2).rename("returns_2")

rho_p_p2 = pd.concat([rho_p, rho_p2], axis=1)
rho_p_p2

En prenant la période \(p\) = 2021-01-01T00:05:00 et un horizon \(k = 0\), le rendement de clôture \(\rho_{p} = r_{p}\) correspond au rapport entre la clôture de la période 2021-01-01T00:05:00 et la clôture de la période 2021-01-01T00:00:00, soit : \[ \rho_{p} = \frac{\text{c}_{p}}{\text{c}_{p-1}} = \frac{28858.94}{28975.65} - 1 \simeq -0.004028 \simeq -0.403 \% \]

En prenant la période \(p\) = 2021-01-01T00:10:00 et un horizon \(k = 2\), le rendement de clôture \(\rho_{p+2}\) correspond au rapport entre la clôture de la période 2021-01-01T00:20:00 et la clôture de la période 2021-01-01T00:05:00, soit : \[ \rho_{p + 2} = \frac{\text{c}_{p+2}}{\text{c}_{p-1}} = \frac{28846.46}{28858.94} - 1 \simeq -0.000432 \simeq -0.043 \% \]

Propriété

Le rendement de clôture entre la période \(p\) et la période \(p + k\), noté \(\rho_{p + k}\), s'exprime en fonction des rendements \(r_{p}, \ldots, r_{p+k}\) (cf. Équation \eqref{org0db3dc9}) comme suit :

Ce résultat classique s'obtient en remarquant que :

Dans notre problématique, la variable cible (c.-à-d. la variable à prédire) représente les rendements futurs du BTC/USDT. Dans un premier temps, il est donc nécessaire de décider de l'horizon futur des rendements à prévoir. Prenons un exemple en considérant un horizon d'une heure. Sachant que les données utilisées sont échantillonnées avec une période de 5 min, il faut calculer à chaque période \(p\) le rendement à \(p + k\) où \(k = 60~\text{min} / 5~\text{min} = 12\).

Commençons par charger les données.

import pandas as pd

ohlcv_df = pd.read_csv("btc_5m_2021_2022.csv.bz2",
                       compression="bz2",
                       index_col="time")

Calculons ensuite les rendements futurs sur un horizon de 1 heure (soit \(k=12\) unités de temps).

k_horizon = 12
returns = ohlcv_df["close"].pct_change(k_horizon+1).shift(-k_horizon).rename(f"r{k_horizon}")

Nous pouvons alors faire une analyse univariée rapide de notre variable cible.

Statistiques de base :

returns.describe()

Premières valeurs (1 semaine = 2016*5 min)

import plotly.express as px

fig_returns = px.line(returns.head(2016), title=f"Rendements du BTC/USDT à p+{k_horizon}",
                      markers=True,
                      labels=dict(
                          value=returns.name))
fig_returns.update_layout(showlegend=False)
fig_returns

Distribution

import plotly.express as px

fig_returns_hist = px.histogram(returns, title="Distribution des rendements du BTC/USDT à p+12",
                                labels=dict(value=returns.name))
fig_returns_hist.update_layout(showlegend=False)
fig_returns_hist

Question à méditer : En tant qu'analyste quantitif, que vous apprennent ces premières analyses sur les rendements du BTC/USDT sur un horizon futur de 1h ?

Dans ce projet, nous proposons d'expliquer les variations du BTC/USDT à partir d'indicateurs techniques financiers. Il existe un très grand nombre d'indicateurs techniques utilisés classiquement dans le domaine de la finance. Parmi les plus connus, on trouve :

• le RSI (Relative Strength Index) ;
• le MACD (Moving Average Convergence Divergence) ;
• les Bandes de Bollinger ;
• le Stochastique.

Tous ces indicateurs se calculent à partir des données OHLCV du BTC/USDT disponibles. De plus, la librairie pandas_ta (pip install pandas_ta) met à disposition les fonctions de calcul des principaux indicateurs techniques.

Les variables explicatives et la variable cible étant quantitatives, la régression linéaire semble a priori une méthode adéquate pour répondre à notre problématique.

Nous choisissons dans un premier temps d'expliquer les rendements à \(p + 12\) (soit les rendements a 1 heure dans le futur) à partir de l'indicateur RSI avec une période de taille 5 en utilisant une régression linéaire. On pose donc l'hypothèse suivante : \[ \text{r12} = \alpha_{0} + \alpha_{1} \text{RSI5}. \] où $α₀ et α₁ sont les paramètres de régression à estimer à partir des données.

Pour ce faire, nous utilisons la librairie statsmodels (pip install statsmodels).

import statsmodels.api as sm

On déclare notre variable cible et on construit le jeu de données contenant à la fois les variables explicatives et la variable cible.

var_target = f"r{k_horizon}"
# On applique un décalage d'une unité de temps aux variables explicatives
# car au début d'une période, on ne peut pas prédire un rendement futur en utilisant
# des indicateurs utilisant la valeur de clôture de cette même période. 
data_all = pd.concat([indics_df.shift(1), returns], axis=1).dropna()
target = data_all[var_target]

La régression linéaire est mise en oeuvre grâce à la classe OLS comme suit :

var_features_mod1 = ["RSI_5"]

# Ajout d'une colonne de 1 afin d'ajouter le paramètre $\alpha_{0}$
features_mod1_df = sm.add_constant(data_all[var_features_mod1])

mod1 = sm.OLS(target, features_mod1_df)
mod1_res = mod1.fit()
mod1_res.summary()

Questions à méditer :

• Avez-vous bien compris pourquoi il est nécessaire de faire indics_df.shift(1) pour décaler les variables explicatives d'une unité de temps avant de construire le modèle de prévision des rendements ?
• À quoi sert la commande sm.add_constant ?
• Comment interpréter les coefficients obtenus ?

Nous choisissons à présent d'expliquer les rendements à \(p + 12\) à partir d'indicateurs RSI et MFI en utilisant toujours une régression linéaire mais cette fois-ci multivariée : \[ \text{r12} = \alpha_{0} + \alpha_{1} \text{RSI5} + \alpha_{2} \text{RSI10} + \alpha_{3}\text{RSI30}+ \alpha_{4} \text{MFI5} + \alpha_{5} \text{MFI10} + \alpha_{6}\text{MFI30} \] où \(\alpha_{0}, \alpha_{1}, \ldots, \alpha_{6}\) sont les paramètres de régression à estimer à partir des données.

Comme précédemment, on met en oeuvre la régression linéaire comme suit :

var_features_mod2 = list(indics_df.columns)

# Ajout d'une colonne de 1 afin d'ajouter le paramètre $\alpha_{0}$
features_mod2_df = sm.add_constant(data_all[var_features_mod2])

mod2 = sm.OLS(target, features_mod2_df)
mod2_res = mod2.fit()
mod2_res.summary()

Questions :

• Quelle approche standard d'évaluation d'un modèle prédictif connaissez-vous ?
• Cette approche est-elle adaptée dans le contexte de ce projet ?
• Du point de vue d'un analyste quantitatif, quels seraient les critères permettant de dire qu'un modèle est bon ou mauvais ?

Pour évaluer les modèles, nous mettons en oeuvre la démarche d'apprentissage/test usuelle. Les données étant chronologiques, nous veillons à ce que les données d'apprentissage correspondent bien à des données antérieures aux données de test.

pct_train = 0.7
nb_train = int(pct_train*len(data_all))

data_all_train = data_all.iloc[:nb_train]
data_all_test = data_all.iloc[nb_train:]
target_train = data_all_train[var_target]
target_test = data_all_test[var_target]

ohlcv_train_df = ohlcv_df.loc[data_all_train.index]
ohlcv_test_df = ohlcv_df.loc[data_all_test.index]

Nous pouvons enfin visualiser sur un même graphique les performances de nos deux modèles ainsi que la performance naturelle du BTC/USDT sur la même période.

La performance naturelle du BTC/USDT correspond simplement à la performance d'un unique achat pour un USDT au début de la période de l'étude et de la vente de notre actif (en BTC) à la fin de la période d'étude :

ohlcv_test_perf = (ohlcv_test_df["close"]/ohlcv_test_df["close"].iloc[0]).rename("USDT:perf")

Visualisation des performances.

models_perf_df = pd.concat([
    ohlcv_test_perf.reset_index().assign(model="btc/usdt"),
    mod1_trades_df["USDT:perf"].reset_index().assign(model="modèle 1"),
    mod2_trades_df["USDT:perf"].reset_index().assign(model="modèle 2"),
    ], axis=0)

fig_models_perf = px.line(models_perf_df,
                          x="time",
                          y="USDT:perf",
                          color="model",
                          markers=False,
                          title="Comparaison des performances des stratégies",
                          labels=dict(
                              perf="Performance"))
fig_models_perf.update_yaxes(
    range=[0, models_perf_df["USDT:perf"].max()*1.05])
fig_models_perf.update_traces(line=dict(width=5))
fig_models_perf